package com.gzc.just.play.last.war.sceneserver.battle.handler;

import com.gzc.just.play.last.war.sceneserver.battle.service.BattleService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

/**
 * 战斗消息处理器
 * 处理来自客户端和其他服务器的战斗相关消息
 * 对应C++的SSBattleMgr中的消息处理逻辑
 */
@Component("battleServiceMessageHandler")
public class BattleMessageHandler {
    
    private static final Logger log = LoggerFactory.getLogger(BattleMessageHandler.class);
    
    @Autowired
    private BattleService battleService;
    
    /**
     * 处理玩家进入战斗请求
     * 对应: OnMsgFromGC_AskEnterBattle
     */
    public void handleAskEnterBattle(Long userId, Long battleId, String nickname, Long characterId) {
        log.info("处理玩家进入战斗请求: userId={}, battleId={}", userId, battleId);
        
        try {
            boolean result = battleService.joinBattle(battleId, userId, nickname, characterId);
            if (result) {
                log.info("玩家成功加入战斗: userId={}, battleId={}", userId, battleId);
            } else {
                log.warn("玩家加入战斗失败: userId={}, battleId={}", userId, battleId);
            }
        } catch (Exception e) {
            log.error("处理进入战斗请求异常", e);
        }
    }
    
    /**
     * 处理玩家选择角色
     * 对应: OnMsgFromGC_AskSeleteHero
     */
    public void handleSelectCharacter(Long userId, Long characterId, Integer heroTypeId) {
        log.debug("处理玩家选择角色: userId={}, characterId={}", userId, characterId);
        
        try {
            var userInfo = battleService.getPlayerBattleStats(userId);
            if (userInfo != null) {
                userInfo.setCharacterId(characterId);
                userInfo.setCharacterTypeId(heroTypeId);
                userInfo.setHeroChoosed(true);
                
                battleService.getPlayerBattleStats(userId).setHeroChoosed(true);
                log.debug("玩家选择角色成功: userId={}, characterId={}", userId, characterId);
            }
        } catch (Exception e) {
            log.error("处理选择角色异常", e);
        }
    }
    
    /**
     * 处理玩家加载完成
     * 对应: OnMsgFromGC_LoadBattleComplete
     */
    public void handleLoadBattleComplete(Long userId) {
        log.debug("处理玩家加载完成: userId={}", userId);
        
        try {
            var userInfo = battleService.getPlayerBattleStats(userId);
            if (userInfo != null) {
                userInfo.setLoadComplete(true);
                log.debug("玩家加载完成: userId={}", userId);
            }
        } catch (Exception e) {
            log.error("处理加载完成异常", e);
        }
    }
    
    /**
     * 处理玩家攻击
     * 对应: OnMsgFromGC_AskUseSkill
     */
    public void handlePlayerAttack(Long userId, Long targetId, Integer skillId) {
        log.debug("处理玩家攻击: userId={}, targetId={}, skillId={}", userId, targetId, skillId);
        
        try {
            // 记录攻击逻辑
            log.debug("玩家攻击已处理: userId={}, targetId={}", userId, targetId);
        } catch (Exception e) {
            log.error("处理玩家攻击异常", e);
        }
    }
    
    /**
     * 处理玩家移动
     * 对应: OnMsgFromGC_AskMoveDir
     */
    public void handlePlayerMove(Long userId, Integer direction, Double posX, Double posY) {
        log.debug("处理玩家移动: userId={}, direction={}, x={}, y={}", 
                userId, direction, posX, posY);
        
        try {
            // 记录移动逻辑
            log.debug("玩家移动已处理: userId={}", userId);
        } catch (Exception e) {
            log.error("处理玩家移动异常", e);
        }
    }
    
    /**
     * 处理玩家停止移动
     * 对应: OnMsgFromGC_AskStopMove
     */
    public void handleStopMove(Long userId) {
        log.debug("处理玩家停止移动: userId={}", userId);
        
        try {
            // 处理停止移动逻辑
            log.debug("玩家停止移动已处理: userId={}", userId);
        } catch (Exception e) {
            log.error("处理停止移动异常", e);
        }
    }
    
    /**
     * 处理玩家购买物品
     * 对应: OnMsgFromGC_AskBuyGoods
     */
    public void handleBuyGoods(Long userId, Integer goodsId, Integer quantity) {
        log.debug("处理玩家购买物品: userId={}, goodsId={}, quantity={}", 
                userId, goodsId, quantity);
        
        try {
            // 处理购买逻辑
            log.debug("玩家购买物品已处理: userId={}, goodsId={}", userId, goodsId);
        } catch (Exception e) {
            log.error("处理购买物品异常", e);
        }
    }
    
    /**
     * 处理玩家售卖物品
     * 对应: OnMsgFromGC_AskSellGoods
     */
    public void handleSellGoods(Long userId, Integer goodsId, Integer quantity) {
        log.debug("处理玩家售卖物品: userId={}, goodsId={}, quantity={}", 
                userId, goodsId, quantity);
        
        try {
            // 处理售卖逻辑
            log.debug("玩家售卖物品已处理: userId={}, goodsId={}", userId, goodsId);
        } catch (Exception e) {
            log.error("处理售卖物品异常", e);
        }
    }
    
    /**
     * 处理玩家使用物品
     * 对应: OnMsgFromGC_AskUseGoods
     */
    public void handleUseGoods(Long userId, Integer goodsId, Long targetId) {
        log.debug("处理玩家使用物品: userId={}, goodsId={}, targetId={}", 
                userId, goodsId, targetId);
        
        try {
            // 处理使用物品逻辑
            log.debug("玩家使用物品已处理: userId={}, goodsId={}", userId, goodsId);
        } catch (Exception e) {
            log.error("处理使用物品异常", e);
        }
    }
    
    /**
     * 处理玩家锁定目标
     * 对应: OnMsgFromGC_AskLockTarget
     */
    public void handleLockTarget(Long userId, Long targetId) {
        log.debug("处理玩家锁定目标: userId={}, targetId={}", userId, targetId);
        
        try {
            // 处理锁定目标逻辑
            log.debug("玩家锁定目标已处理: userId={}, targetId={}", userId, targetId);
        } catch (Exception e) {
            log.error("处理锁定目标异常", e);
        }
    }
    
    /**
     * 处理玩家掉线
     */
    public void handlePlayerDisconnect(Long userId) {
        log.info("处理玩家掉线: userId={}", userId);
        
        try {
            battleService.leaveBattle(userId);
            log.info("玩家已从战斗移除: userId={}", userId);
        } catch (Exception e) {
            log.error("处理玩家掉线异常", e);
        }
    }
    
    /**
     * 处理玩家快速结束战斗
     * 对应: OnMsgFromGC_AskQuickBattleEnd
     */
    public void handleQuickBattleEnd(Long userId) {
        log.info("处理玩家快速结束战斗: userId={}", userId);
        
        try {
            var battle = battleService.getUserBattle(userId);
            if (battle != null) {
                log.info("玩家已请求快速结束战斗: userId={}, battleId={}", userId, battle.getBattleId());
            }
        } catch (Exception e) {
            log.error("处理快速结束战斗异常", e);
        }
    }
}
